<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        * {
            padding: 0;
            margin: 0;
        }

        li {
            list-style: none;
        }

        h2 {
            height: 40px;
            line-height: 40px;
            text-indent: 10px;
        }

        .list li {
            height: 40px;
            line-height: 40px;
            border: 1px dashed #333;
            text-indent: 10px;
        }

        .list li+li {
            border-top: 0;
        }
    </style>
</head>

<body>
    <div class="wrap">
        <h2 id="title">批量操作元素</h2>
        <ul class="list">
            <li>01</li>
            <li>02</li>
            <li>03</li>
            <li>04</li>
            <li>05</li>
            <li>06</li>
        </ul>
    </div>
</body>
<script>
    // 对象DOM操作一系列操作进行封装
    // 获取元素 操作元素(修改元素的内容(text html value) 修改属性 样式 绑定事件)

    // 按功能划分


    // 构造函数版
    function GetEle(selector) { // 接收一个css选择器(字符串)
        // {}
        // {}[[Prototype]] = GetEle.prototype;
        // this -> {}

        var list = document.querySelectorAll(selector); // 伪数组 (伪数组直接改[[Prototype]]有问题)
        list = Array.from(list); // 先转真数组 
        Object.setPrototypeOf(list, GetEle.prototype); // 再改伪数组
        return list; //  返回自定义的实例化对象(伪数组 ->元素的集合)  list = [li, li, li, li, li, li]
    }


    // GetEle.prototype.setText = function (text) {
    //     // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
    //     // 每次都要先通过实例化对象 -> 获取元素的集合 -> 在操作元素的集合 =>  稍稍有些麻烦
    //     for (var i = 0; i < this.length; i++) { //遍历集合中的每个元素
    //         var li = this[i];
    //         li.textContent = text;
    //     }
    // }
    // GetEle.prototype.getText = function () {
    //     return this[0].textContent;  // 默认返回集合中的第一个
    // }

    // text()   获取和设置集合(实例化对象)中元素的text内容
    // text("1111")  有内容就设置
    // text()        没有内容就获取

    GetEle.prototype.text = function (text) {
        if (arguments.length >= 1) { //有至少一个参数
            // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
            // 每次都要先通过实例化对象 -> 获取元素的集合 -> 在操作元素的集合 =>  稍稍有些麻烦
            // for (var i = 0; i < this.length; i++) { //遍历集合中的每个元素
            //     var li = this[i];
            //     li.textContent = text;
            // }

            this.each(function (ele, index) {
                ele.textContent = text;
            })
        } else { // 没有参数就获取
            return this[0].textContent;  // 默认返回集合中的第一个
        }

    }

    // html()        获取和设置集合(实例化对象)中元素的html结构
    // html("1111")  有内容就设置
    // html()        没有内容就获取
    GetEle.prototype.html = function (html) {
        if (arguments.length >= 1) { //有至少一个参数
            // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
            // 每次都要先通过实例化对象 -> 获取元素的集合 -> 在操作元素的集合 =>  稍稍有些麻烦
            // for (var i = 0; i < this.length; i++) { //遍历集合中的每个元素
            //     var li = this[i];
            //     li.innerHTML = html;
            // }

            this.each(function (ele, index) {
                ele.innerHTML = html;
            })
        } else { // 没有参数就获取
            return this[0].innerHTML;  // 默认返回集合中的第一个
        }

    }

    // val()        获取和设置集合(实例化对象)中元素的value结构
    // val("1111")  有内容就设置
    // val()        没有内容就获取
    GetEle.prototype.val = function (con) {
        if (arguments.length >= 1) { //有至少一个参数
            // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
            // 每次都要先通过实例化对象 -> 获取元素的集合 -> 在操作元素的集合 =>  稍稍有些麻烦
            // for (var i = 0; i < this.length; i++) { //遍历集合中的每个元素
            //     var li = this[i];
            //     li.value = con;
            // }

            this.each(function (ele, index) {
                ele.value = con;
            })
        } else { // 没有参数就获取
            return this[0].value;  // 默认返回集合中的第一个
        }
    }

    // on(type,callbackFn) 绑定事件(事件监听绑定 => 可以给一个元素绑定多个相同类型的事件)
    // 可以绑定所有类型的事件
    GetEle.prototype.on = function (type, callbackFn) { // type:绑定事件类型 callbackFn 事件触发时执行的回调函数
        // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
        // for (var i = 0; i < this.length; i++) {
        //     var ele = this[i];
        //     ele.addEventListener(type, callbackFn)
        // }

        this.each(function (ele, index) {
            ele.addEventListener(type, callbackFn)
        })
    }

    // 针对特定类型绑定 
    // click dblclick mousedown -> 基于on方法二次封装得到的 
    GetEle.prototype.click = function (callbackFn) {
        // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
        this.on("click", callbackFn);
    }

    // off(type,callbackFn) 清除绑定事件(事件监听绑定 => 可以给一个元素绑定多个相同类型的事件)
    GetEle.prototype.off = function (type, callbackFn) { // type:绑定事件类型 callbackFn 事件触发时执行的回调函数
        // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]
        // for (var i = 0; i < this.length; i++) {
        //     var ele = this[i];
        //     ele.removeEventListener(type, callbackFn)
        // }

        this.each(function (ele, index) {
            ele.removeEventListener(type, callbackFn);
        })
    }

    GetEle.prototype.each = function (callbackFn) {
        // this -> 调用此方法的实例化对象(伪数组 -> 元素的集合)  [li,li,li,li,li,li]

        // 遍历实例化对象(元素的集合) 每次循环时执行传入的函数
        for (var i = 0; i < this.length; i++) {
            var item = this[i];
            // i
            // this -> 原数组
            // callbackFn(item, i, this);
            callbackFn.call(item, item, i, this);  //调用函数 -> 将this指向循环的当前元素
        }
    }



    var titleObj = new GetEle("#title");
    console.log(titleObj);
    // titleObj.text('11111');
    // titleObj.text('');


    var lisObj = new GetEle(".list li");
    console.log(lisObj);
    // lisObj.text(22222);


    lisObj.each(function (item, index, array) { // 此函数作为参数传入
        // console.log(item, index, array);
        console.log(this);
    })



</script>

</html>